La technologie jupyter permet d'exécuter du code python par un simple clique sur Executer ci-dessus.
Les morceaux de code de cette page sont interprétées case par case. Pour savoir quelle case a été interprétée avant une autre, il suffit de repérer le numéro devant la case.
Une fois qu'une case a été interprétée (=exécutée), la page garde en mémoire les variables et fonctions lues
La plateforme propose quelques outils de purge de la mémoire :
Pour ne pas perdre votre travail pensez à le sauvegarder régulièrement. Par défault, la sauvegarde par un clic sur la disquette en haut à gauche de page, ou par le racourci clavier classique ctrl+S
est une sauvegarde en local, sur le serveur de jupyter. Vous pouvez et devez très régulièrement sauvegarder votre travail sur votre support personnel de sauvegarde (clef USB, se l'envoyer par mail etc). Ce faisant vous disposerez d'un fichier .ipynb (IPYthon NoteBook) qu'il vous suffira de recharger pour avancer. Après le rechargement assurez vous que les fonctionnalités anciennement developpées et variables utilisées sont bien dans la mémoire de la page (en rééxecutant les cases, ou plus rapidement par Kernel > Restart & Run All.
A NOTER : vous pouvez travailler sur le tp (et tout autre fichier .ipynb) hors connexion en installant une version local du notebook de jupyter. Il faut que votre machine possède un interpreteur de python et que vous soyez connecter à internet.
pip install jupyterlabjupyter notebook
Il ne s'agit pas ici de faire un cours de python mais simplement de rappeler les éléments majeurs que nous allons utiliser pour programmer. Si vous êtes familier avec le langage vous pouvez aller directement à la première partie.
Les tableaux (cliquez pour ouvrir)
Il existe plusieurs moyens de faire des tableaux en python. Nous revennons sur les deux dont nous abuserons tout au long de ce TP :
Si vous n'êtes pas très familier avec les tableaux, le choix des dictionnaires est un bon compromis.
Il est nécessaire de déclarer les listes. Pour ce faire, il suffit d'écrire
append qui va ajouter la valeur passée en paramètre à la fin du tableau.
L.append(4)
Il est nécessaire de déclarer les dictionnaires. Pour ce faire, il suffit d'écrire
L[0]=4
Quelque soit le choix de structure que vous faites, la fonction len vous donnera la taille du tableau.
print(len(L))#Affichera 0
L.append(4)
L.append(-1)
print(len(L))#Affichera 2Les boucles (cliquez pour ouvrir)
Il existe en python deux outils permettant de faire des boucles.
while
C'est la boucle la plus confortable mais qui peut générer des itérations infinies si le test n'est pas bien pensé ou l'itérateur mal incrémenté
Une fois cette boucle lancée, nul besoin de controler l'itérateur ou de gérer le test. Lorsque l'on veut parcourir les entiers entre $a$ et $b$ d'un pas de $p$ on l'utilise avec range(a, b, p) qui génére un tableau (liste) de nombre entre $a$ et $b-1$ de $p$ en $p$
range(a, b, p) créé une liste d'entier entre $a$ et $b-1$).
La boucle for permet de se servir de n'importe quel tableau comme ensemble d'indice. Attention cependant, dictionnaire et liste n'engendre pas le même ensemble.
for i in L :
for i in L :
Considérons la liste suivante
L=list(range(0, 20, 3))
print(L)
Nous souhaitons faire la somme des carrés des termes de cette suite. Voici deux solutions : une avec la boucle while et l'autre avec la boucle for.
#Avec une boucle while (6 lignes)
res1=0
i=0
while(i<len(L)) :
res1+=L[i]**2
i+=1
print("res1 =", res1)
#Avec une boucle for (3 lignes)
res2=0
for x in L : res2+=x**2
print("res2 =", res2)
Donner la liste des 100 premier terme de la suite $u_n=\dfrac{(-1)^n+1}{2}$.
Un=[]
for n in range(0, 100, 1) :
Un.append(((-1)**n+1)/2)
print(Un)
Suivant la parité de $n$, on observe que $u_n$ prend des valeurs bien particulière. Ecrire une fonction f qui prend un paramètre n et renvoie $u_n$ sans calculer $\dfrac{(-1)^n+1}{2}$. Exécuter la case suivante permettant de vérifier votre formule.
def f(n) :
if(n%2==0) : return 1.0
return 0.0
N=[0, 10, 25, 50, 75]
for n in N :
print("Pour n =", n, "\n\tFormule1 =", Un[n], "\n\tFormule2 =", f(n))
if(Un[n]==f(n)) : print("\tTout va bien")
else : print("\tPROBLEME !!!")
Nous allons comparer les temps de calculs. Pour cela nous avons besoin de la fonction time de la bibliothèque éponyme.
from time import time
Pour déterminer le nombre de seconde écouler depuis le 1er janvier 1970, on appel la fonction time sans paramètre.
x=time()
print(x)
Ainsi pour déterminer le temps d'exécution d'un programe, on fait un top avant l'algorithme et un top à la fin. La différence de ces deux top donnera donc le nombre de seconde écouler le temps de l'éxécution du programme.
top=time()
for i in range(10**6) :
i=i**2
print("Temps :", time()-top)
Le code suivant donne le temps de calcul de $u_{n}$ pour $n=10^{10^6}$ (dix puissance un million)
n=10**(10**6) #On place le calcul de n avant le comptage du temps de calcul
top=time()
x=((-1)**(n)+1)/2
print("Temps de calcul de u_n :", time()-top)
Faisons le même calcul en passant par la fonction f déterminée précédement.
n=10**(10**6)
top=time()
x=f(n)
print("Temps de calcul de u_n :", time()-top)
Ainsi avoir remarqué que $u_n=f(n)$ pour une fonction $f$ pas trop compliqué simplifie considérablement les temps de calcul.
Calculer $\displaystyle{\sum_{n=0}^{99}u_n}$.
res=0
for un in Un :
res+=un
print("Résultat :", res)
Calculer $\displaystyle{\sum_{n=0}^{999999}u_n}$.
#Il parait plus raisonnable, aux vues des temps de calcul, de passer par la fonction f
res=0
for n in range(10**6) : res+=f(n)
print("Résultat :", res)
On peut montrer par récurrence que $\displaystyle{\sum_{k=0}^n k=\dfrac{n(n+1)}{2}}$. Calculer la somme pour $n=10$, $n=1000$ et $n=1983$ et vérifier qu'elle est bien égale à l'expression $\dfrac{n(n+1)}{2}$
N=[10, 1000, 1983]
for n in N :
s=0
for k in range(0, n+1, 1) : s+=k
x=(n*(n+1))/2
print("Sommation :", s)
print("Formule :", x)
if(s==x) : print("\tTout va bien")
else : print("\tPROBLEME !!")
On peut montrer par récurrence que $\displaystyle{\sum_{k=0}^n k^2=\dfrac{n(n+1)(2n-1)}{6}}$. Calculer la somme pour $n=10$, $n=1000$ et $n=1983$ et vérifier qu'elle est bien égale à l'expression $\dfrac{n(n+1)(2n+1)}{6}$
N=[10, 1000, 1983]
for n in N :
s=0
for k in range(0, n+1, 1) : s+=k**2
x=(n*(n+1)*(2*n+1))/6
print("Sommation :", s)
print("Formule :", x)
if(s==x) : print("\tTout va bien")
else : print("\tPROBLEME !!")
On peut montrer par récurrence que $\displaystyle{\sum_{k=0}^n 2^k=2^{n+1}-1}$. Calculer la somme pour $n=10$, $n=1000$ et $n=1983$ et vérifier qu'elle est bien égale à l'expression $2^{n+1}-1$
N=[10, 1000, 1983]
for n in N :
s=0
for k in range(0, n+1, 1) : s+=2**k
x=2**(n+1)-1
print("Sommation :", s)
print("Formule :", x)
if(s==x) : print("\tTout va bien")
else : print("\tPROBLEME !!")
On peut montrer que pour tout $x\in\mathbb{R}_+$, il existe un entier $N\in \mathbb{N}$ tel que $\displaystyle{\sum_{n=1}^{N}\dfrac{1}{n}>x}$. Déterminer le plus petit $N$ pour $x=5$, $x=10$, $x=15$ et $x=20$. Mesurer les temps de calcul.
X=[5, 10, 15, 20]
for x in X :
top=time()
s=0
n=1
while(s<=x) :
s+=1/n
n+=1
n-=1
print("Pour N =", n, "on atteint", x)
print("\tTemps de calcul :", time()-top)